gdk_event_get_event_type
gdk_event_get_surface
gdk_event_get_device
-gdk_event_get_source_device
gdk_event_get_device_tool
gdk_event_get_time
gdk_event_get_display
event = gdk_crossing_event_new (GDK_ENTER_NOTIFY,
surface,
display_broadway->core_pointer,
- display_broadway->pointer,
message->base.time,
message->pointer.state,
message->pointer.win_x,
event = gdk_crossing_event_new (GDK_LEAVE_NOTIFY,
surface,
display_broadway->core_pointer,
- display_broadway->pointer,
message->base.time,
message->pointer.state,
message->pointer.win_x,
{
event = gdk_motion_event_new (surface,
display_broadway->core_pointer,
- display_broadway->pointer,
NULL,
message->base.time,
message->pointer.state,
: GDK_BUTTON_RELEASE,
surface,
display_broadway->core_pointer,
- display_broadway->pointer,
NULL,
message->base.time,
message->pointer.state,
{
event = gdk_scroll_event_new_discrete (surface,
display_broadway->core_pointer,
- display_broadway->pointer,
NULL,
message->base.time,
0,
GUINT_TO_POINTER (message->touch.sequence_id),
surface,
display_broadway->core_pointer,
- display_broadway->touchscreen,
message->base.time,
state,
message->touch.win_x,
: GDK_KEY_RELEASE,
surface,
display_broadway->core_keyboard,
- display_broadway->keyboard,
message->base.time,
message->key.key,
message->key.state,
{
event = gdk_focus_event_new (surface,
display_broadway->core_keyboard,
- display_broadway->keyboard,
FALSE);
node = _gdk_event_queue_append (display, event);
{
event = gdk_focus_event_new (surface,
display_broadway->core_keyboard,
- display_broadway->keyboard,
TRUE);
node = _gdk_event_queue_append (display, event);
GdkEvent *event;
event = gdk_grab_broken_event_new (surface,
- device,
device,
grab_surface,
implicit);
g_clear_object (&self->surface);
g_clear_object (&self->device);
- g_clear_object (&self->source_device);
g_type_free_instance ((GTypeInstance *) self);
}
* @event_type: the #GdkEventType to allocate
* @surface: (nullable): the #GdkSurface of the event
* @device: (nullable): the #GdkDevice of the event
- * @source_device: (nullable): the source #GdkDevice of the event
* @time_: the event serial
*
* Allocates a #GdkEvent for the given @event_type, and sets its
gdk_event_alloc (GdkEventType event_type,
GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
guint32 time_)
{
g_assert (event_type >= GDK_DELETE && event_type < GDK_EVENT_LAST);
event->event_type = event_type;
event->surface = surface != NULL ? g_object_ref (surface) : NULL;
event->device = device != NULL ? g_object_ref (device) : NULL;
- event->source_device = source_device != NULL ? g_object_ref (source_device) : NULL;
event->time = time_;
return event;
return FALSE;
}
- if (event->source_device != NULL &&
- gdk_surface_get_display (event->surface) != gdk_device_get_display (event->source_device))
- {
- char *type = g_enum_to_string (GDK_TYPE_EVENT_TYPE, event->event_type);
- g_warning ("Event of type %s with mismatched source device display", type);
- g_free (type);
- return FALSE;
- }
-
return TRUE;
}
#endif
gdk_scroll_event_get_deltas (old_event, &dx, &dy);
event = gdk_scroll_event_new (surface,
device,
- gdk_event_get_source_device (old_event),
gdk_event_get_device_tool (old_event),
gdk_event_get_time (old_event),
gdk_event_get_modifier_state (old_event),
return event->device;
}
-/**
- * gdk_event_get_source_device:
- * @event: a #GdkEvent
- *
- * This function returns the physical #GdkDevice that has triggered
- * the event, falling back to the logical device, as returned by
- * gdk_event_get_device(), if the event wasn’t caused by
- * interaction with a hardware device. This may happen for example
- * in synthesized crossing events after a #GdkSurface updates its
- * geometry or a grab is acquired/released.
- *
- * If the event does not contain a device field, this function will
- * return %NULL.
- *
- * Returns: (nullable) (transfer none): a #GdkDevice, or %NULL.
- **/
-GdkDevice *
-gdk_event_get_source_device (GdkEvent *event)
-{
- g_return_val_if_fail (GDK_IS_EVENT (event), NULL);
-
- if (event->source_device)
- return event->source_device;
-
- return event->device;
-}
-
/**
* gdk_event_get_device_tool:
* @event: a #GdkEvent
guint *n_axes)
{
GdkButtonEvent *self = (GdkButtonEvent *) event;
- GdkDevice *source_device = gdk_event_get_source_device (event);
+ GdkDevice *source_device = gdk_event_get_device (event);
if (source_device == NULL)
return FALSE;
gdk_button_event_new (GdkEventType type,
GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
GdkDeviceTool *tool,
guint32 time,
GdkModifierType state,
g_return_val_if_fail (type == GDK_BUTTON_PRESS ||
type == GDK_BUTTON_RELEASE, NULL);
- GdkButtonEvent *self = gdk_event_alloc (type, surface, device, source_device, time);
+ GdkButtonEvent *self = gdk_event_alloc (type, surface, device, time);
self->tool = tool != NULL ? g_object_ref (tool) : NULL;
self->axes = axes;
* @type: the event type, either %GDK_KEY_PRESS or %GDK_KEY_RELEASE
* @surface: the #GdkSurface of the event
* @device: the #GdkDevice related to the event
- * @source_device: the source #GdkDevice related to the event
* @time: the event's timestamp
* @keycode: the keycode of the event
* @state: the modifiers state
gdk_key_event_new (GdkEventType type,
GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
guint32 time,
guint keycode,
GdkModifierType state,
g_return_val_if_fail (type == GDK_KEY_PRESS ||
type == GDK_KEY_RELEASE, NULL);
- GdkKeyEvent *self = gdk_event_alloc (type, surface, device, source_device, time);
+ GdkKeyEvent *self = gdk_event_alloc (type, surface, device, time);
GdkEvent *event = (GdkEvent *) self;
self->keycode = keycode;
g_return_val_if_fail (width >= 0 && height >= 0, NULL);
- self = gdk_event_alloc (GDK_CONFIGURE, surface, NULL, NULL, GDK_CURRENT_TIME);
+ self = gdk_event_alloc (GDK_CONFIGURE, surface, NULL, GDK_CURRENT_TIME);
self->width = width;
self->height = height;
guint *n_axes)
{
GdkTouchEvent *self = (GdkTouchEvent *) event;
- GdkDevice *source_device = gdk_event_get_source_device (event);
+ GdkDevice *source_device = gdk_event_get_device (event);
if (source_device == NULL)
return FALSE;
GdkEventSequence *sequence,
GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
guint32 time,
GdkModifierType state,
double x,
type == GDK_TOUCH_UPDATE ||
type == GDK_TOUCH_CANCEL, NULL);
- self = gdk_event_alloc (type, surface, device, source_device, time);
+ self = gdk_event_alloc (type, surface, device, time);
self->sequence = sequence;
self->state = state;
self->x = x;
gdk_crossing_event_new (GdkEventType type,
GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
guint32 time,
GdkModifierType state,
double x,
g_return_val_if_fail (type == GDK_ENTER_NOTIFY ||
type == GDK_LEAVE_NOTIFY, NULL);
- self = gdk_event_alloc (type, surface, device, source_device, time);
+ self = gdk_event_alloc (type, surface, device, time);
self->state = state;
self->x = x;
GdkEvent *
gdk_delete_event_new (GdkSurface *surface)
{
- return gdk_event_alloc (GDK_DELETE, surface, NULL, NULL, GDK_CURRENT_TIME);
+ return gdk_event_alloc (GDK_DELETE, surface, NULL, GDK_CURRENT_TIME);
}
/* }}} */
GdkEvent *
gdk_focus_event_new (GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
gboolean focus_in)
{
- GdkFocusEvent *self = gdk_event_alloc (GDK_FOCUS_CHANGE, surface, device, source_device, GDK_CURRENT_TIME);
+ GdkFocusEvent *self = gdk_event_alloc (GDK_FOCUS_CHANGE, surface, device, GDK_CURRENT_TIME);
self->focus_in = focus_in;
GdkEvent *
gdk_scroll_event_new (GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
GdkDeviceTool *tool,
guint32 time,
GdkModifierType state,
double delta_y,
gboolean is_stop)
{
- GdkScrollEvent *self = gdk_event_alloc (GDK_SCROLL, surface, device, source_device, time);
+ GdkScrollEvent *self = gdk_event_alloc (GDK_SCROLL, surface, device, time);
self->tool = tool != NULL ? g_object_ref (tool) : NULL;
self->state = state;
GdkEvent *
gdk_scroll_event_new_discrete (GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
GdkDeviceTool *tool,
guint32 time,
GdkModifierType state,
GdkScrollDirection direction,
gboolean emulated)
{
- GdkScrollEvent *self = gdk_event_alloc (GDK_SCROLL, surface, device, source_device, time);
+ GdkScrollEvent *self = gdk_event_alloc (GDK_SCROLL, surface, device, time);
self->tool = tool != NULL ? g_object_ref (tool) : NULL;
self->state = state;
GdkEvent *
gdk_touchpad_event_new_swipe (GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
guint32 time,
GdkModifierType state,
GdkTouchpadGesturePhase phase,
double dx,
double dy)
{
- GdkTouchpadEvent *self = gdk_event_alloc (GDK_TOUCHPAD_SWIPE, surface, device, source_device, time);
+ GdkTouchpadEvent *self = gdk_event_alloc (GDK_TOUCHPAD_SWIPE, surface, device, time);
self->state = state;
self->phase = phase;
GdkEvent *
gdk_touchpad_event_new_pinch (GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
guint32 time,
GdkModifierType state,
GdkTouchpadGesturePhase phase,
double scale,
double angle_delta)
{
- GdkTouchpadEvent *self = gdk_event_alloc (GDK_TOUCHPAD_PINCH, surface, device, source_device, time);
+ GdkTouchpadEvent *self = gdk_event_alloc (GDK_TOUCHPAD_PINCH, surface, device, time);
self->state = state;
self->phase = phase;
GdkEvent *
gdk_pad_event_new_ring (GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
guint32 time,
guint group,
guint index,
guint mode,
double value)
{
- GdkPadEvent *self = gdk_event_alloc (GDK_PAD_RING, surface, device, source_device, time);
+ GdkPadEvent *self = gdk_event_alloc (GDK_PAD_RING, surface, device, time);
self->group = group;
self->index = index;
GdkEvent *
gdk_pad_event_new_strip (GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
guint32 time,
guint group,
guint index,
guint mode,
double value)
{
- GdkPadEvent *self = gdk_event_alloc (GDK_PAD_STRIP, surface, device, source_device, time);
+ GdkPadEvent *self = gdk_event_alloc (GDK_PAD_STRIP, surface, device, time);
self->group = group;
self->index = index;
gdk_pad_event_new_button (GdkEventType type,
GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
guint32 time,
guint group,
guint button,
g_return_val_if_fail (type == GDK_PAD_BUTTON_PRESS ||
type == GDK_PAD_BUTTON_RELEASE, NULL);
- self = gdk_event_alloc (type, surface, device, source_device, time);
+ self = gdk_event_alloc (type, surface, device, time);
self->group = group;
self->button = button;
GdkEvent *
gdk_pad_event_new_group_mode (GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
guint32 time,
guint group,
guint mode)
{
- GdkPadEvent *self = gdk_event_alloc (GDK_PAD_GROUP_MODE, surface, device, source_device, time);
+ GdkPadEvent *self = gdk_event_alloc (GDK_PAD_GROUP_MODE, surface, device, time);
self->group = group;
self->mode = mode;
guint *n_axes)
{
GdkMotionEvent *self = (GdkMotionEvent *) event;
- GdkDevice *source_device = gdk_event_get_source_device (event);
+ GdkDevice *source_device = gdk_event_get_device (event);
if (source_device == NULL)
return FALSE;
GdkEvent *
gdk_motion_event_new (GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
GdkDeviceTool *tool,
guint32 time,
GdkModifierType state,
double y,
double *axes)
{
- GdkMotionEvent *self = gdk_event_alloc (GDK_MOTION_NOTIFY, surface, device, source_device, time);
+ GdkMotionEvent *self = gdk_event_alloc (GDK_MOTION_NOTIFY, surface, device, time);
self->tool = tool ? g_object_ref (tool) : NULL;
self->state = state;
gdk_proximity_event_new (GdkEventType type,
GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
GdkDeviceTool *tool,
guint32 time)
{
g_return_val_if_fail (type == GDK_PROXIMITY_IN ||
type == GDK_PROXIMITY_OUT, NULL);
- self = gdk_event_alloc (type, surface, device, source_device, time);
+ self = gdk_event_alloc (type, surface, device, time);
self->tool = tool ? g_object_ref (tool) : NULL;
type == GDK_DRAG_LEAVE ||
type == GDK_DROP_START, NULL);
- self = gdk_event_alloc (type, surface, device, NULL, time);
+ self = gdk_event_alloc (type, surface, device, time);
self->drop = drop != NULL ? g_object_ref (drop) : NULL;
self->x = x;
GdkEvent *
gdk_grab_broken_event_new (GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
GdkSurface *grab_surface,
gboolean implicit)
{
- GdkGrabBrokenEvent *self = gdk_event_alloc (GDK_GRAB_BROKEN, surface, device, source_device, GDK_CURRENT_TIME);
+ GdkGrabBrokenEvent *self = gdk_event_alloc (GDK_GRAB_BROKEN, surface, device, GDK_CURRENT_TIME);
self->grab_surface = grab_surface;
self->implicit = implicit;
GDK_AVAILABLE_IN_ALL
GdkDevice * gdk_event_get_device (GdkEvent *event);
-GDK_AVAILABLE_IN_ALL
-GdkDevice * gdk_event_get_source_device (GdkEvent *event);
-
GDK_AVAILABLE_IN_ALL
GdkDeviceTool * gdk_event_get_device_tool (GdkEvent *event);
* @event_type: the specialized event type
* @surface: the surface of the event
* @device: the device of the event
- * @source_device: the source device
* @time: a serial identifier of the event that can be used to order
* two events
* @flags: event flags
/* The devices associated to the event */
GdkDevice *device;
- GdkDevice *source_device;
guint32 time;
guint16 flags;
GdkEvent * gdk_button_event_new (GdkEventType type,
GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
GdkDeviceTool *tool,
guint32 time,
GdkModifierType state,
GdkEvent * gdk_motion_event_new (GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
GdkDeviceTool *tool,
guint32 time,
GdkModifierType state,
GdkEvent * gdk_crossing_event_new (GdkEventType type,
GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
guint32 time,
GdkModifierType state,
double x,
GdkEvent * gdk_proximity_event_new (GdkEventType type,
GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
GdkDeviceTool *tool,
guint32 time);
GdkEvent * gdk_key_event_new (GdkEventType type,
GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
guint32 time,
guint keycode,
GdkModifierType modifiers,
GdkEvent * gdk_focus_event_new (GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
gboolean focus_in);
GdkEvent * gdk_configure_event_new (GdkSurface *surface,
GdkEvent * gdk_scroll_event_new (GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
GdkDeviceTool *tool,
guint32 time,
GdkModifierType state,
GdkEvent * gdk_scroll_event_new_discrete (GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
GdkDeviceTool *tool,
guint32 time,
GdkModifierType state,
GdkEventSequence *sequence,
GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
guint32 time,
GdkModifierType state,
double x,
GdkEvent * gdk_touchpad_event_new_swipe (GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
guint32 time,
GdkModifierType state,
GdkTouchpadGesturePhase phase,
GdkEvent * gdk_touchpad_event_new_pinch (GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
guint32 time,
GdkModifierType state,
GdkTouchpadGesturePhase phase,
GdkEvent * gdk_pad_event_new_ring (GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
guint32 time,
guint group,
guint index,
GdkEvent * gdk_pad_event_new_strip (GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
guint32 time,
guint group,
guint index,
GdkEvent * gdk_pad_event_new_button (GdkEventType type,
GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
guint32 time,
guint group,
guint button,
GdkEvent * gdk_pad_event_new_group_mode (GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
guint32 time,
guint group,
guint mode);
GdkEvent * gdk_grab_broken_event_new (GdkSurface *surface,
GdkDevice *device,
- GdkDevice *source_device,
GdkSurface *grab_surface,
gboolean implicit);
gboolean unlink_event = FALSE;
GdkDeviceGrabInfo *button_release_grab;
GdkPointerSurfaceInfo *pointer_info = NULL;
- GdkDevice *device, *source_device;
+ GdkDevice *device;
GdkEventType type;
_gdk_display_update_last_event (display, event);
device = gdk_event_get_device (event);
- source_device = gdk_event_get_source_device (event);
if (device)
{
gdk_device_get_source (device) != GDK_SOURCE_TABLET_PAD)
{
pointer_info = _gdk_display_get_pointer_info (display, device);
-
- if (source_device != pointer_info->last_physical_device &&
- gdk_device_get_device_type (source_device) == GDK_DEVICE_TYPE_PHYSICAL)
- pointer_info->last_physical_device = source_device;
- else if (pointer_info->last_physical_device)
- source_device = pointer_info->last_physical_device;
+ pointer_info->last_physical_device = device;
}
_gdk_display_device_grab_update (display, device, serial);
event = gdk_crossing_event_new (type,
surface,
device,
- device,
time_,
state,
x, y,
event = gdk_crossing_event_new (type,
surface,
device,
- source,
time_,
0,
touch->x, touch->y,
gboolean focus_in,
guint32 time_)
{
- GdkEvent *event = gdk_focus_event_new (surface, device, device, focus_in);
+ GdkEvent *event = gdk_focus_event_new (surface, device, focus_in);
_gdk_wayland_display_deliver_event (gdk_surface_get_display (surface), event);
}
source = get_scroll_device (seat, seat->pointer_info.frame.source);
event = gdk_scroll_event_new_discrete (seat->pointer_info.focus,
- seat->logical_pointer,
source,
NULL,
seat->pointer_info.time,
source = get_scroll_device (seat, seat->pointer_info.frame.source);
event = gdk_scroll_event_new (seat->pointer_info.focus,
- seat->logical_pointer,
source,
NULL,
seat->pointer_info.time,
event = gdk_crossing_event_new (GDK_ENTER_NOTIFY,
seat->pointer_info.focus,
seat->logical_pointer,
- seat->pointer,
0,
0,
seat->pointer_info.surface_x,
event = gdk_crossing_event_new (GDK_LEAVE_NOTIFY,
seat->pointer_info.focus,
seat->logical_pointer,
- seat->pointer,
0,
0,
seat->pointer_info.surface_x,
event = gdk_motion_event_new (seat->pointer_info.focus,
seat->logical_pointer,
- seat->pointer,
NULL,
time,
device_get_modifiers (seat->logical_pointer),
event = gdk_button_event_new (state ? GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE,
seat->pointer_info.focus,
seat->logical_pointer,
- seat->pointer,
NULL,
time,
device_get_modifiers (seat->logical_pointer),
event = gdk_focus_event_new (seat->keyboard_focus,
seat->logical_keyboard,
- seat->keyboard,
TRUE);
GDK_SEAT_NOTE (seat, EVENTS,
event = gdk_focus_event_new (seat->keyboard_focus,
seat->logical_keyboard,
- seat->keyboard,
FALSE);
g_object_unref (seat->keyboard_focus);
event = gdk_key_event_new (state ? GDK_KEY_PRESS : GDK_KEY_RELEASE,
seat->keyboard_focus,
seat->logical_keyboard,
- seat->keyboard,
time_,
key,
device_get_modifiers (seat->logical_pointer),
GDK_SLOT_TO_EVENT_SEQUENCE (touch->id),
touch->surface,
seat->logical_touch,
- seat->touch,
time,
device_get_modifiers (seat->logical_touch),
touch->x, touch->y,
GDK_SLOT_TO_EVENT_SEQUENCE (touch->id),
touch->surface,
seat->logical_touch,
- seat->touch,
time,
device_get_modifiers (seat->logical_touch),
touch->x, touch->y,
GDK_SLOT_TO_EVENT_SEQUENCE (touch->id),
touch->surface,
seat->logical_touch,
- seat->touch,
time,
device_get_modifiers (seat->logical_touch),
touch->x, touch->y,
GDK_SLOT_TO_EVENT_SEQUENCE (touch->id),
touch->surface,
seat->logical_touch,
- seat->touch,
GDK_CURRENT_TIME,
device_get_modifiers (seat->logical_touch),
touch->x, touch->y,
seat->pointer_info.time = _time;
event = gdk_touchpad_event_new_swipe (seat->pointer_info.focus,
- seat->logical_pointer,
seat->pointer,
_time,
device_get_modifiers (seat->logical_pointer),
seat->pointer_info.time = _time;
event = gdk_touchpad_event_new_pinch (seat->pointer_info.focus,
- seat->logical_pointer,
seat->pointer,
_time,
device_get_modifiers (seat->logical_pointer),
seat->logical_touch = g_object_new (GDK_TYPE_WAYLAND_DEVICE,
"name", "Wayland Touch Logical Pointer",
"type", GDK_DEVICE_TYPE_LOGICAL,
- "source", GDK_SOURCE_MOUSE,
+ "source", GDK_SOURCE_TOUCHSCREEN,
"has-cursor", TRUE,
"display", seat->display,
"seat", seat,
{
seat->wheel_scrolling = g_object_new (GDK_TYPE_WAYLAND_DEVICE,
"name", "Wayland Wheel Scrolling",
- "type", GDK_DEVICE_TYPE_PHYSICAL,
+ "type", GDK_DEVICE_TYPE_LOGICAL,
"source", GDK_SOURCE_MOUSE,
"has-cursor", TRUE,
"display", seat->display,
"seat", seat,
NULL);
- _gdk_device_set_associated_device (seat->wheel_scrolling, seat->logical_pointer);
- gdk_seat_device_added (GDK_SEAT (seat), seat->wheel_scrolling);
+ gdk_seat_device_added (GDK_SEAT (seat), seat->wheel_scrolling);
}
return seat->wheel_scrolling;
{
seat->finger_scrolling = g_object_new (GDK_TYPE_WAYLAND_DEVICE,
"name", "Wayland Finger Scrolling",
- "type", GDK_DEVICE_TYPE_PHYSICAL,
+ "type", GDK_DEVICE_TYPE_LOGICAL,
"source", GDK_SOURCE_TOUCHPAD,
"has-cursor", TRUE,
"display", seat->display,
"seat", seat,
NULL);
- _gdk_device_set_associated_device (seat->finger_scrolling, seat->logical_pointer);
- gdk_seat_device_added (GDK_SEAT (seat), seat->finger_scrolling);
+ gdk_seat_device_added (GDK_SEAT (seat), seat->finger_scrolling);
}
return seat->finger_scrolling;
{
seat->continuous_scrolling = g_object_new (GDK_TYPE_WAYLAND_DEVICE,
"name", "Wayland Continuous Scrolling",
- "type", GDK_DEVICE_TYPE_PHYSICAL,
+ "type", GDK_DEVICE_TYPE_LOGICAL,
"source", GDK_SOURCE_TRACKPOINT,
"has-cursor", TRUE,
"display", seat->display,
"seat", seat,
NULL);
- _gdk_device_set_associated_device (seat->continuous_scrolling, seat->logical_pointer);
- gdk_seat_device_added (GDK_SEAT (seat), seat->continuous_scrolling);
+ gdk_seat_device_added (GDK_SEAT (seat), seat->continuous_scrolling);
}
return seat->continuous_scrolling;
event = gdk_proximity_event_new (GDK_PROXIMITY_IN,
tablet->pointer_info.focus,
tablet->logical_device,
- tablet->stylus_device,
tool->tool,
tablet->pointer_info.time);
gdk_wayland_tablet_set_frame_event (tablet, event);
event = gdk_proximity_event_new (GDK_PROXIMITY_OUT,
tablet->pointer_info.focus,
tablet->logical_device,
- tablet->stylus_device,
tool->tool,
tablet->pointer_info.time);
gdk_wayland_tablet_set_frame_event (tablet, event);
event = gdk_button_event_new (evtype,
tablet->pointer_info.focus,
tablet->logical_device,
- tablet->stylus_device,
tablet->current_tool->tool,
tablet->pointer_info.time,
device_get_modifiers (seat->logical_pointer),
event = gdk_motion_event_new (tablet->pointer_info.focus,
tablet->logical_device,
- tablet->stylus_device,
tool->tool,
tablet->pointer_info.time,
device_get_modifiers (tablet->logical_device),
/* Send smooth event */
event = gdk_scroll_event_new (tablet->pointer_info.focus,
tablet->logical_device,
- tablet->stylus_device,
tablet->current_tool->tool,
tablet->pointer_info.time,
device_get_modifiers (tablet->logical_device),
/* Send discrete event */
event = gdk_scroll_event_new_discrete (tablet->pointer_info.focus,
- tablet->logical_device,
tablet->stylus_device,
tablet->current_tool->tool,
tablet->pointer_info.time,
g_message ("tablet pad ring handle frame, ring = %p", wp_tablet_pad_ring));
event = gdk_pad_event_new_ring (seat->keyboard_focus,
- pad->device,
pad->device,
time,
g_list_index (pad->mode_groups, group),
wp_tablet_pad_strip));
event = gdk_pad_event_new_strip (seat->keyboard_focus,
- pad->device,
pad->device,
time,
g_list_index (pad->mode_groups, group),
n_group = g_list_index (pad->mode_groups, group);
event = gdk_pad_event_new_group_mode (seat->keyboard_focus,
- pad->device,
pad->device,
time,
n_group,
: GDK_PAD_BUTTON_RELEASE,
GDK_WAYLAND_SEAT (pad->seat)->keyboard_focus,
pad->device,
- pad->device,
time,
n_group,
button,
if (event)
{
- GdkDevice *source = gdk_event_get_source_device (event);
+ GdkDevice *source = gdk_event_get_device (event);
GdkWaylandSeat *wayland_seat = GDK_WAYLAND_SEAT (seat);
GList *l;
GDK_SLOT_TO_EVENT_SEQUENCE (touch->id),
touch->surface,
seat->logical_touch,
- seat->touch,
GDK_CURRENT_TIME,
device_get_modifiers (seat->logical_touch),
touch->x, touch->y,
event = gdk_button_event_new (event_type,
window,
device_manager->core_pointer,
- GDK_DEVICE (source_device),
NULL,
_gdk_win32_get_next_tick (msg->time),
event_state,
event = gdk_motion_event_new (window,
device_manager->core_pointer,
- GDK_DEVICE (source_device),
NULL,
_gdk_win32_get_next_tick (msg->time),
event_state,
gboolean in)
{
GdkDevice *device;
- GdkDevice *source_device;
GdkEvent *event;
device = GDK_DEVICE_MANAGER_WIN32 (device_manager)->core_keyboard;
- source_device = GDK_DEVICE_MANAGER_WIN32 (device_manager)->system_keyboard;
- event = gdk_focus_event_new (window, device, source_device, in);
+ event = gdk_focus_event_new (window, device, in);
_gdk_win32_append_event (event);
}
{
GdkEvent *event;
GdkDevice *device;
- GdkDevice *source_device;
if (keyboard)
- {
- device = device_manager->core_keyboard;
- source_device = device_manager->system_keyboard;
- }
+ device = device_manager->core_keyboard;
else
- {
- device = device_manager->core_pointer;
- source_device = device_manager->system_pointer;
- }
+ device = device_manager->core_pointer;
event = gdk_grab_broken_event_new (window,
device,
- source_device,
grab_window,
FALSE);
event = gdk_crossing_event_new (type,
window,
device_manager->core_pointer,
- device_manager->system_pointer,
_gdk_win32_get_next_tick (time_),
mask,
pt.x / impl->surface_scale,
event = gdk_button_event_new (type,
window,
device_manager->core_pointer,
- device_manager->system_pointer,
NULL,
_gdk_win32_get_next_tick (msg->time),
build_pointer_event_state (msg),
event = gdk_key_event_new (GDK_KEY_PRESS,
window,
device_manager_win32->core_keyboard,
- device_manager_win32->system_keyboard,
_gdk_win32_get_next_tick (msg->time),
0,
0,
: GDK_KEY_RELEASE,
window,
device_manager_win32->core_keyboard,
- device_manager_win32->system_keyboard,
_gdk_win32_get_next_tick (msg->time),
state,
keycode,
event = gdk_key_event_new (GDK_KEY_PRESS,
window,
device_manager_win32->core_keyboard,
- device_manager_win32->system_keyboard,
_gdk_win32_get_next_tick (msg->time),
build_key_event_state (key_state),
0,
event = gdk_key_event_new (GDK_KEY_RELEASE,
window,
device_manager_win32->core_keyboard,
- device_manager_win32->system_keyboard,
_gdk_win32_get_next_tick (msg->time),
build_key_event_state (key_state),
0,
event = gdk_motion_event_new (window,
device_manager_win32->core_pointer,
- device_manager_win32->system_pointer,
NULL,
_gdk_win32_get_next_tick (msg->time),
build_pointer_event_state (msg),
event = gdk_scroll_event_new (window,
device_manager_win32->core_pointer,
- device_manager_win32->system_pointer,
NULL,
_gdk_win32_get_next_tick (msg->time),
build_pointer_event_state (msg),
event = gdk_scroll_event_new_discrete (window,
device_manager_win32->core_pointer,
- device_manager_win32->system_pointer,
NULL,
_gdk_win32_get_next_tick (msg->time),
build_pointer_event_state (msg),
{
GdkEvent *event;
- event = gdk_focus_event_new (surface, device, source_device, focus_in);
+ event = gdk_focus_event_new (surface, device, focus_in);
gdk_display_put_event (gdk_surface_get_display (surface), event);
gdk_event_unref (event);
}
: GDK_KEY_RELEASE,
surface,
device,
- source_device,
xev->time,
xev->detail,
state,
GUINT_TO_POINTER (xev->sourceid));
event = gdk_scroll_event_new_discrete (surface,
- device,
source_device,
NULL,
xev->time,
: GDK_BUTTON_RELEASE,
surface,
device,
- source_device,
source_device->last_tool,
xev->time,
_gdk_x11_device_xi2_translate_state (&xev->mods, &xev->buttons, &xev->group),
event = gdk_scroll_event_new (surface,
device,
- source_device,
NULL,
xev->time,
_gdk_x11_device_xi2_translate_state (&xev->mods, &xev->buttons, &xev->group),
event = gdk_motion_event_new (surface,
device,
- source_device,
source_device->last_tool,
xev->time,
_gdk_x11_device_xi2_translate_state (&xev->mods, &xev->buttons, &xev->group),
GUINT_TO_POINTER (xev->detail),
surface,
device,
- source_device,
xev->time,
state,
x, y,
GUINT_TO_POINTER (xev->detail),
surface,
device,
- source_device,
xev->time,
state,
x, y,
: GDK_LEAVE_NOTIFY,
surface,
device,
- source_device,
xev->time,
state,
(double) xev->event_x / scale,
focus_event = gdk_focus_event_new (gdk_event_get_surface (event),
gdk_event_get_device (event),
- gdk_event_get_source_device (event),
focus_in);
gdk_display_put_event (gdk_event_get_display (event), focus_event);
gdk_event_unref (focus_event);
event = gdk_crossing_event_new (evtype,
gdk_event_get_surface (real_event),
gdk_event_get_device (real_event),
- gdk_event_get_source_device (real_event),
gdk_event_get_time (real_event),
gdk_event_get_modifier_state (real_event),
x, y,
direction = gdk_scroll_event_get_direction (event);
if (direction == GDK_SCROLL_SMOOTH)
{
- GdkDevice *device = gdk_event_get_source_device (event);
+ GdkDevice *device = gdk_event_get_device (event);
GdkInputSource input_source = gdk_device_get_source (device);
gdk_scroll_event_get_deltas (event, &dx, &dy);
sequence = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
event = gtk_gesture_get_last_event (GTK_GESTURE (gesture), sequence);
- source = gdk_device_get_source (gdk_event_get_source_device (event));
+ source = gdk_device_get_source (gdk_event_get_device (event));
if (source == GDK_SOURCE_TOUCHSCREEN)
modify = !modify;
GdkModifierType state;
GtkWidget *target;
- source_device = gdk_event_get_source_device (event);
+ source_device = gdk_event_get_device (event);
if (!source_device)
return FALSE;
priv = gtk_gesture_click_get_instance_private (click);
event = gtk_gesture_get_last_event (gesture, sequence);
current = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
- device = gdk_event_get_source_device (event);
+ device = gdk_event_get_device (event);
event_type = gdk_event_get_event_type (event);
if (event_type == GDK_BUTTON_PRESS)
gboolean retval, test_touchscreen = FALSE;
GdkEventType event_type;
- source_device = gdk_event_get_source_device (event);
+ source_device = gdk_event_get_device (event);
if (!source_device)
return FALSE;
key = gdk_key_event_new (press ? GDK_KEY_PRESS : GDK_KEY_RELEASE,
surface,
device,
- source_device,
time,
keycode,
state,
GdkEvent *tmp_event = gdk_key_event_new (GDK_KEY_PRESS,
gdk_event_get_surface (event),
gdk_event_get_device (event),
- gdk_event_get_source_device (event),
gdk_event_get_time (event),
priv->compose_buffer[len + i],
gdk_event_get_modifier_state (event),
state = gdk_event_get_modifier_state (event);
extend = (state & GDK_SHIFT_MASK) != 0;
modify = (state & GDK_CONTROL_MASK) != 0;
- source = gdk_device_get_source (gdk_event_get_source_device (event));
+ source = gdk_device_get_source (gdk_event_get_device (event));
if (source == GDK_SOURCE_TOUCHSCREEN)
modify = !modify;
return gdk_button_event_new (type,
new_surface,
gdk_event_get_device (event),
- gdk_event_get_source_device (event),
gdk_event_get_device_tool (event),
gdk_event_get_time (event),
gdk_event_get_modifier_state (event),
case GDK_MOTION_NOTIFY:
return gdk_motion_event_new (new_surface,
gdk_event_get_device (event),
- gdk_event_get_source_device (event),
gdk_event_get_device_tool (event),
gdk_event_get_time (event),
gdk_event_get_modifier_state (event),
gdk_event_get_event_sequence (event),
new_surface,
gdk_event_get_device (event),
- gdk_event_get_source_device (event),
gdk_event_get_time (event),
gdk_event_get_modifier_state (event),
x, y,
gdk_touchpad_event_get_deltas (event, &dx, &dy);
return gdk_touchpad_event_new_swipe (new_surface,
gdk_event_get_device (event),
- gdk_event_get_source_device (event),
gdk_event_get_time (event),
gdk_event_get_modifier_state (event),
gdk_touchpad_event_get_gesture_phase (event),
gdk_touchpad_event_get_deltas (event, &dx, &dy);
return gdk_touchpad_event_new_pinch (new_surface,
gdk_event_get_device (event),
- gdk_event_get_source_device (event),
gdk_event_get_time (event),
gdk_event_get_modifier_state (event),
gdk_touchpad_event_get_gesture_phase (event),
return gdk_key_event_new (gdk_event_get_event_type (event),
surface,
gdk_event_get_device (event),
- gdk_event_get_source_device (event),
gdk_event_get_time (event),
gdk_key_event_get_keycode (event),
gdk_event_get_modifier_state (event),
type = gdk_event_get_event_type (event);
sequence = gdk_event_get_event_sequence (event);
+ if (type == GDK_SCROLL &&
+ (gdk_device_get_source (device) == GDK_SOURCE_TOUCHPAD ||
+ gdk_device_get_source (device) == GDK_SOURCE_TRACKPOINT ||
+ gdk_device_get_source (device) == GDK_SOURCE_MOUSE))
+ {
+ /* A bit of a kludge, resolve target lookups for scrolling devices
+ * on the seat pointer.
+ */
+ device = gdk_seat_get_pointer (gdk_event_get_seat (event));
+ }
+
switch ((guint) type)
{
case GDK_LEAVE_NOTIFY:
return TRUE;
if (pad_controller->pad &&
- gdk_event_get_source_device (event) != pad_controller->pad)
+ gdk_event_get_device (event) != pad_controller->pad)
return TRUE;
return FALSE;
if (event_type == GDK_PAD_GROUP_MODE)
{
gtk_pad_controller_handle_mode_switch (pad_controller,
- gdk_event_get_source_device (event),
+ gdk_event_get_device (event),
group,
mode);
return GDK_EVENT_PROPAGATE;
sequence = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
event = gtk_gesture_get_last_event (GTK_GESTURE (gesture), sequence);
- device = gdk_event_get_source_device (event);
+ device = gdk_event_get_device (event);
paned->panning = FALSE;
is_touch = (gdk_event_get_event_type (event) == GDK_TOUCH_BEGIN ||
state_mask = gdk_event_get_modifier_state (event);
shift_pressed = (state_mask & GDK_SHIFT_MASK) != 0;
- source_device = gdk_event_get_source_device ((GdkEvent *) event);
+ source_device = gdk_event_get_device ((GdkEvent *) event);
source = gdk_device_get_source (source_device);
g_object_get (gtk_widget_get_settings (widget),
state = gtk_event_controller_get_current_event_state (controller);
event = gtk_event_controller_get_current_event (controller);
- source_device = gdk_event_get_source_device (event);
+ source_device = gdk_event_get_device (event);
input_source = gdk_device_get_source (source_device);
if (priv->hscrollbar_visible)
sel_end = priv->current_pos;
have_selection = sel_start != sel_end;
- source = gdk_event_get_source_device (event);
+ source = gdk_event_get_device (event);
is_touchscreen = gtk_simulate_touchscreen () ||
gdk_device_get_source (source) == GDK_SOURCE_TOUCHSCREEN;
else
tmp_pos = gtk_text_find_position (self, x);
- source = gdk_event_get_source_device (event);
+ source = gdk_event_get_device (event);
input_source = gdk_device_get_source (source);
if (priv->select_words)
GTK_EVENT_SEQUENCE_CLAIMED);
gtk_text_view_reset_blink_time (text_view);
- device = gdk_event_get_source_device ((GdkEvent *) event);
+ device = gdk_event_get_device ((GdkEvent *) event);
is_touchscreen = gtk_simulate_touchscreen () ||
gdk_device_get_source (device) == GDK_SOURCE_TOUCHSCREEN;
drag_gesture_get_text_surface_coords (gesture, text_view,
&start_x, &start_y, &x, &y);
- device = gdk_event_get_source_device (event);
+ device = gdk_event_get_device (event);
is_touchscreen = gtk_simulate_touchscreen () ||
gdk_device_get_source (device) == GDK_SOURCE_TOUCHSCREEN;
return;
event = gtk_gesture_get_last_event (GTK_GESTURE (gesture), sequence);
- device = gdk_event_get_source_device (event);
+ device = gdk_event_get_device (event);
is_touchscreen = gtk_simulate_touchscreen () ||
gdk_device_get_source (device) == GDK_SOURCE_TOUCHSCREEN;
GDK_BUTTON5_MASK)) != 0)
return FALSE;
- source_device = gdk_event_get_source_device (event);
+ source_device = gdk_event_get_device (event);
if (!source_device)
return FALSE;
gdk_event_get_event_sequence (event),
gdk_event_get_surface (event),
gdk_event_get_device (event),
- gdk_event_get_source_device (event),
gdk_event_get_time (event),
gdk_event_get_modifier_state (event),
p.x, p.y,
press = gdk_button_event_new (GDK_BUTTON_PRESS,
gdk_event_get_surface (event),
gdk_event_get_device (event),
- gdk_event_get_source_device (event),
gdk_event_get_device_tool (event),
gdk_event_get_time (event),
gdk_event_get_modifier_state (event),
press = gdk_button_event_new (GDK_BUTTON_PRESS,
gdk_event_get_surface (event),
gdk_event_get_device (event),
- gdk_event_get_source_device (event),
gdk_event_get_device_tool (event),
gdk_event_get_time (event),
gdk_event_get_modifier_state (event),
event->event_type = event_type;
event->surface = g_object_ref (surface);
event->device = g_object_ref (device);
- event->source_device = g_object_ref (source_device);
event->time = time_;
key_event->keycode = keycode;
projects / gtk4.git / commitdiff